package QianFeng08.CollectionDemo;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 集合的输出（迭代）
 * 前面我们已经学习了集合的基本操作，很多情况下，我们需要把集合的内容进行输出，也就是遍历集合。
 * 遍历集合的方式有以下几种:Iterator、ListIterator、Enumeration、foreach，其中foreach的使用率最高。
 * <p>
 * JDK1.8新特性
 * Consumer<T>接口    消费者接口
 * Function<T,R>接口  表示接受一个参数并产生结果的函数
 * Supplier<T>接口    代表结果供应商
 * Predicate<T>接口   断言接口
 **/
public class IteratorDemo {
    public static void main(String[] args) {
        List<Cat> cats = new ArrayList<>();
        Cat Cat1 = new Cat("大佬", 5, 1);
        Cat Cat2 = new Cat("大神", 2, 2);
        Cat Cat3 = new Cat("菜鸟", 4, 3);
        Cat Cat4 = new Cat("老手", 4, 4);
        cats.add(Cat1);
        cats.add(Cat2);
        cats.add(Cat3);
        cats.add(Cat4);

        iterator1(cats);
        iterator2(cats);
        enumeration();
        forEach();
        functionTest();
        supplierTest();
        predicateTest();
    }
    /*-----------------------------------------------迭代方法-----------------------------------------------*/
    //foreach 迭代  1.5后
    private static void iterator1(Collection<Cat> cat) {
        for (Cat c : cat) {
            System.out.println(c);
        }
    }

    //Iterator 迭代  1.5前统一迭代集合方法
    private static void iterator2(Collection<Cat> cat) {
        Iterator<Cat> iterator = cat.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //Enumeration 迭代  1.5后
    private static void enumeration() {
        Vector<String> vector = new Vector<>();
        vector.add("tom");
        vector.add("jak");
        vector.add("luci");
        vector.add("snack");

        Enumeration<String> es = vector.elements();
        while (es.hasMoreElements()) {
            System.out.println(es.nextElement());
        }
    }

    /*-----------------------------------------------JDK1.8新特性-----------------------------------------------*/
    /**
     * JDK1.8新的迭代方法
     * Consumer  forEach
     **/
    private static void forEach() {
        List<String> fLists = new ArrayList<>();
        fLists.add("大神");
        fLists.add("大佬");
        fLists.add("高手");
        fLists.add("菜鸟");
        //Lambda表达式
        fLists.forEach(s -> System.out.println(s));
        fLists.forEach(System.out::println);//更简洁的方法
    }

    /**
     * JDK1.8新的迭代方法
     * Function<T, R>
     * T参数  R 结果    R apply<T t>
     * 表示接受一个参数并产生结果的函数
     **/
    private static void functionTest() {
        String s = strToUpp("qf_sunshine", (str) -> str.toUpperCase());
        //方法的引用 String s = strToUpp("qf_sunshine", String::toUpperCase);
        System.out.println(s);
    }
    public static String strToUpp(String str, Function<String, String> function) {
        return function.apply(str);
    }

    /**
     * JDK1.8新的迭代方法
     * Supplier(T)   T get()
     * 获取一个结果  返回a result
     * 代表结果供应商
     **/
    private static void supplierTest() {
        List<Integer> integerSupplier = getNums(10, () -> (int) (Math.random() * 100));
        integerSupplier.forEach(System.out::println);
    }
    private static List<Integer> getNums(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return  list;
    }

    /**
     * JDK1.8新的迭代方法
     * Predicate<T>       boolean test(T t);
     * 断言接口
     **/
    private static void predicateTest() {
        List<String> list = Arrays.asList("Larry", "Tom", "Curly", "QF");
        List<String> result = filter(list, (s) -> s.contains("o"));
        result.forEach(System.out::println);
    }

    private static List<String> filter(List<String> list, Predicate<String> predicate) {
        List<String> result = new ArrayList<>();
        for (String s : list) {
            if (predicate.test(s)) { //测试是否符合要求
                result.add(s);
            }
        }
        return result;
    }




}
